#include<iostream>
using namespace std;

//内部类
class A
{
public:
	class B   //内部类是外部类的友元
	{
	public:
		B(int b=1)
		{
			_b = b;
		}
		void foo(const A& a)
		{
			cout << a._a << endl;//OK
		}
	private:
		int _b;

	};

	A(int a=1)
	{
		_a = a;
	}
	//B bb();
private:
	int _a;
};

//匿名对象
class C
{
public:
	C(int c = 1)
	{
		_c = c;
		cout << "C(int c = 1)" << endl;
	}

	C(const C& c)
	{
		_c = c._c;
		cout << "C(const C& c)" << endl;
	}
	~C()
	{
		_c = 0;
		cout << "~C()" << endl;
	}
	void print()
	{
		cout << _c << endl;
	}

private:
	int _c;
};

//构造函数的优化

//传值传参  调用拷贝构造函数
void func1(C c)
{

}

//传引用传参 不调用拷贝构造函数
void func2(const C& c)
{
	
}

//值返回
C func3()
{
	C cc;
	return cc;  //调用拷贝构造函数
}

//引用返回
C& func4()
{
	C cc;
	return cc;  //不调用拷贝构造函数
}

void Func6(C cc)
{}

C Func7()
{
	C cc;
	return cc;
}
int main()
{
	//A aa;  //外部类定义的对象中不包含内部类
	//A::B bb(1);  //外部类类域限制和访问限定符限制
	//cout << sizeof(A) << endl;

	//C cc(1);  //有名对象  生命周期为函数局部域
	//C(2);   //匿名对象 生命周期为本行

	////C& CC = C(2);  //匿名对象具有常性
	//const C& CC = C(2);  //延长匿名对象的生命周期到函数局部域

	//C().print();  //匿名对象调用函数

	/*C cc;

	func1(cc);
	func2(cc);
	func3();
	func4();*/

	//// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022）
	C cc1 = Func7();  //拷贝构造+拷贝构造-->优化为一个拷贝构造

	C cc2;
	Func6(cc2);  //构造+拷贝构造-->不会优化因为不在同一行实现

	Func6(C(1));  //构造+拷贝构造-->优化为一个构造
	Func6(2);  //构造+拷贝构造-->优化为一个构造  隐式类型转换
	C cc3 = 3;  //构造+拷贝构造-->优化为一个构造  隐式类型转换


}